package com.tool.cn.util;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;


/**
 * 集合与数组工具类
 * 
 * @author wangzh
 * 2016年9月18日 上午9:17:16
 */
public final class CollectionUtil {

	/**
	 * 判断数组是否为空
	 */
	public static boolean isNotEmptyArray(Object[] array){
		return !isEmptyArray(array);
	}
	
	/**
	 * 集合合并
	 * @param source
	 * @param data
	 * @return
	 */
	public static List<String> addAll(List<String> source,List<String> data){
		if(isNotEmptyCollection(data)) {
			source.addAll(data);
		}
		return source;
	}
	
	/**
	 * 判断数组是否非空
	 */
	public static boolean isEmptyArray(Object[] array){
		if(array!=null&&array.length>0){
			return false;
		}
		return true;
	}
	
	/**
	 * 判断collection是否为空
	 */
	public static boolean isEmptyCollection(Collection<?> collection){
		if(collection!=null&&collection.size()>0){
			return false;
		}
		return true;
	}
	
	/**
	 * 判断collection是否非空
	 */
	public static boolean isNotEmptyCollection(Collection<?> collection){
		return !isEmptyCollection(collection);
	}
	
	/**
	 * 判断Map是否为空
	 */
	public static boolean isEmptyMap(Map<?,?> map){
		if(map!=null&&map.size()>0){
			return false;
		}
		return true;
	}
	
	/**
	 * 判断Map是否非空
	 */
	public static boolean isNotEmptyMap(Map<?,?> map){
		return !isEmptyMap(map);
	}
	
	/**
	 * String数组转int
	 */
	public static Integer[] StringToInt(String[] arrs) {
		Integer[] ints = new Integer[arrs.length];
		for (int i = 0; i < arrs.length; i++) {
			ints[i] = Integer.parseInt(arrs[i]);
		}
		return ints;
	}
	
	/**
	 * 判断list集合是否有重复数据，不含重复true  含重复 false 
	 * @param list
	 * @return
	 */
	public static <T> boolean listNotRepeat(List<T> list) {
		Set<T> set = new HashSet<T>(list);
        List<T> tempList = new ArrayList<T>(set);
        return list.size()==tempList.size();
	}
	
	/**
	 * list数据去重，保留顺序
	 */
	public static<T> List<T> repeatData(List<T> list){
		LinkedHashSet<T> hashSet =new LinkedHashSet<T>(list);
		 
		List<T> listWithoutDuplicates =new ArrayList<T>(hashSet);
		return listWithoutDuplicates;
	}
	
	/**
	 * 数组合并
	 * @param array1 数组一
	 * @param array2 数组二
	 * @return
	 */
	public static Object[] addAll(Object[] array1, Object[] array2) {
		if (array1 == null)
		  return clone(array2); 
		if (array2 == null) {
		  return clone(array1);
		}
		Object[] joinedArray = (Object[])Array.newInstance(array1.getClass().getComponentType(), array1.length + array2.length);

		System.arraycopy(array1, 0, joinedArray, 0, array1.length);
		try {
		  System.arraycopy(array2, 0, joinedArray, array1.length, array2.length);
		} catch (ArrayStoreException e) {
		  Class<?> type1 = array1.getClass().getComponentType();
		  Class<?> type2 = array2.getClass().getComponentType();
		  if (!type1.isAssignableFrom(type2)) {
		    throw new IllegalArgumentException("Cannot store " + type2.getName() + " in an array of " + type1.getName());
		  }
		  throw e;
		} 
		  return joinedArray;
		}
	
	/**
	 * 数组克隆
	 * @param array
	 * @return
	 */
	public static Object[] clone(Object[] array) {
		  if (array == null) {
		    return null;
		  }
		  return (Object[])array.clone();
	}
	
	/**
	 * 数组去重
	 * @param dataList
	 * @return
	 */
	public static String[] checkArray(String[] dataList) {
		//实例化一个set集合  
	    Set<String> set = new HashSet<>();  
	    //遍历数组并存入集合,如果元素已存在则不会重复存入  
	    for (int i = 0; i < dataList.length; i++) {  
	    	if(StringUtil.isNotEmpty(dataList[i])) {
	    		set.add(dataList[i]);  
	    	}
	    }  
	    return set.toArray(new String[set.size()]);
	}
	
	/**
	 * 可重复数组组合
	 * @param list 源字符串数组
	 * @param result
	 * @param resultList 结果结合，取key
	 */
	public void create(String[] list,LinkedHashMap<Integer,String> result,Map<String,Integer>  resultList) {
		if(list.length>10) {
			System.out.println("数据源数组大于10，计算量过大。无法处理");
			return;
		}
		
		if(result.size()==list.length) {
			String value=StringUtil.CollectionToString(result.values());
			if(!resultList.containsKey(value)) {
				resultList.put(value,0);
			}
			
			return;
		}
		
		for(int i=0;i<list.length;i++) {
			
			if(!result.containsKey(i)) {
				result.put(i, list[i]);
				//回调
				create(list, result,resultList);
				
				result.remove(getLastElement(result.keySet()));
			}
		}
	}
	
	/**
	 * set 对象获取最后一个
	 * @param <T>
	 * @param elements
	 * @return
	 */
	public  static <T> T getLastElement(Iterable<T> elements) {
	    T lastElement = null;

	    for (T element : elements) {
	        lastElement = element;
	    }

	    return lastElement;
	}
	
}
